using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;
using Microsoft.Xna.Framework.Net;
using Microsoft.Xna.Framework.Storage;

namespace XNA2dTutorial
{
    /// <summary>
    /// This is the main type for your game
    /// </summary>
    public class TutorialGame : Microsoft.Xna.Framework.Game
    {
        GraphicsDeviceManager graphics;
        SpriteBatch spriteBatch;

        Texture2D background;

        Rectangle viewportRectangle;
        GameObject cannon;

        const int maxCannonBalls = 100;
        GameObject[] cannonBalls;
        GamePadState previousGamePadState = GamePad.GetState(PlayerIndex.One);
        KeyboardState previousKeyboardsate = Keyboard.GetState();
        const int maxEnemis = 3;
        const float maxEnemyHeight = 0.1f;
        const float minEnemyHeight = 0.5f;
        const float maxEnemyVelocity = 5.0f;
        const float minEnemyVelocity = 1.0f;
        Random random = new Random();
        GameObject[] enemies;
        int score;
        SpriteFont font;
        Vector2 scoreDrawPoint = new Vector2(
            0.1f, 0.1f);



        public TutorialGame()
        {
            graphics = new GraphicsDeviceManager(this);
            Content.RootDirectory = "Content";
        }

        /// <summary>
        /// Allows the game to perform any initialization it needs to before starting to run.
        /// This is where it can query for any required services and load any non-graphic
        /// related content.  Calling base.Initialize will enumerate through any components
        /// and initialize them as well.
        /// </summary>
        protected override void Initialize()
        {
            // TODO: Add your initialization logic here

            base.Initialize();
        }

        /// <summary>
        /// LoadContent will be called once per game and is the place to load
        /// all of your content.
        /// </summary>
        protected override void LoadContent()
        {
            // Create a new SpriteBatch, which can be used to draw textures.
            spriteBatch = new SpriteBatch(GraphicsDevice);

            background = Content.Load<Texture2D>("Sprites\\background");
            
            cannon = new GameObject(Content.Load<Texture2D>("Sprites\\cannon"));
            cannon.position = new Vector2(120,graphics.GraphicsDevice.Viewport.Height - 80);
            cannonBalls = new GameObject[maxCannonBalls];
            for (int i = 0; i < maxCannonBalls; i++)
            {
                cannonBalls[i] = new GameObject(Content.Load<Texture2D>("Sprites\\cannonball"));
            }

            enemies = new GameObject[maxEnemis];
            for (int i = 0; i < maxEnemis; i++)
            {
                enemies[i] = new GameObject(Content.Load<Texture2D>("Sprites\\enemy"));
            }
            font = Content.Load<SpriteFont>("Fonts\\GameFont"); 

            viewportRectangle = new Rectangle(0, 0, graphics.GraphicsDevice.Viewport.Width, graphics.GraphicsDevice.Viewport.Height);

            // TODO: use this.Content to load your game content here
        }

        /// <summary>
        /// UnloadContent will be called once per game and is the place to unload
        /// all content.
        /// </summary>
        protected override void UnloadContent()
        {
            // TODO: Unload any non ContentManager content here
        }

        /// <summary>
        /// Allows the game to run logic such as updating the world,
        /// checking for collisions, gathering input, and playing audio.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Update(GameTime gameTime)
        {
            // Allows the game to exit
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
                this.Exit();

            GamePadState gamePadState = GamePad.GetState(PlayerIndex.One);

            cannon.rotation += gamePadState.ThumbSticks.Left.X * 0.1f;
            if (gamePadState.Buttons.A == ButtonState.Pressed && previousGamePadState.Buttons.A == ButtonState.Released)
            {
                FireCannonBall();
            }

#if !XBOX
            KeyboardState keyboardState = Keyboard.GetState();
            if(keyboardState.IsKeyDown(Keys.Left))
            {
                cannon.rotation -= 0.01f;
            }

            if(keyboardState.IsKeyDown(Keys.Right))
            {
                cannon.rotation += 0.01f;

            }
            if (keyboardState.IsKeyDown(Keys.Space) && previousKeyboardsate.IsKeyUp(Keys.Space))
            {
                FireCannonBall();
            }
#endif
            cannon.rotation = MathHelper.Clamp(cannon.rotation, -MathHelper.PiOver2, 0);
            UpdateCannonBalls();
            UpdateEnemies();
            // TODO: Add your update logic here

            previousGamePadState = gamePadState;

#if !XBOX
            previousKeyboardsate=keyboardState;
#endif


            base.Update(gameTime);
        }

        private void UpdateEnemies()
        {
            foreach (GameObject enemy in enemies)
            {
                if (enemy.alive)
                {
                    enemy.position += enemy.velocity;
                    if (!viewportRectangle.Contains(new Point((int)enemy.position.X, (int)enemy.position.Y)))
                    {
                        enemy.alive = false;
                    }
                }
                else
                {
                    enemy.alive = true;
                    enemy.position = new Vector2(viewportRectangle.Right, MathHelper.Lerp((float)viewportRectangle.Height * minEnemyHeight, (float)viewportRectangle.Height * maxEnemyHeight,(float)random.NextDouble()));
                    enemy.velocity = new Vector2(
                        MathHelper.Lerp(-minEnemyVelocity, -maxEnemyVelocity, (float)random.NextDouble()), 0);

                }
            }
        }

        public void FireCannonBall()
        {
            foreach (GameObject ball in cannonBalls)
            {
                if (!ball.alive)
                {
                    ball.alive = true;
                    ball.position = cannon.position;
                    ball.velocity = new Vector2((float)Math.Cos(cannon.rotation),(float)Math.Sin(cannon.rotation))*5.0f;
                    return ;
                }
            }

        }

        private void UpdateCannonBalls()
        {
            foreach (GameObject ball in cannonBalls)
            {
                if (ball.alive)
                {
                    ball.position += ball.velocity;
                    if (!viewportRectangle.Contains(new Point((int)ball.position.X, (int)ball.position.Y)))
                    {
                        ball.alive = false;
                        continue;
                    }
                    Rectangle cannonBallrect = new Rectangle(
                        (int)ball.position.X,
                        (int)ball.position.Y,
                        ball.sprite.Width,
                        ball.sprite.Height);
                    foreach (GameObject enemy in enemies)
                    {
                        Rectangle enemyRect = new Rectangle(
                            (int)enemy.position.X,
                            (int)enemy.position.Y,
                            enemy.sprite.Width,
                            enemy.sprite.Height);

                        if (cannonBallrect.Intersects(enemyRect))
                        {
                            ball.alive = false;
                            enemy.alive = false;
                            score += 1;
                            break;
                        }
                    }

                }

            }
        }

        /// <summary>
        /// This is called when the game should draw itself.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Draw(GameTime gameTime)
        {
            GraphicsDevice.Clear(Color.CornflowerBlue);
            spriteBatch.Begin(SpriteBlendMode.AlphaBlend);
            // TODO: Add your drawing code here

            //Draw the background
            spriteBatch.Draw(background, viewportRectangle, Color.White);

            foreach(GameObject ball in cannonBalls)

            {
                if(ball.alive)
                {
                    spriteBatch.Draw(ball.sprite, ball.position, Color.White);
                }
            }

            foreach (GameObject enemy in enemies)
            {
                if (enemy.alive)
                {
                    spriteBatch.Draw(enemy.sprite, enemy.position, Color.White);
                }
            }
            spriteBatch.DrawString(font, "Score: " + score.ToString(), new Vector2(scoreDrawPoint.X * viewportRectangle.Width, scoreDrawPoint.Y * viewportRectangle.Height), Color.Yellow);

            //Draw cannon
            spriteBatch.Draw(cannon.sprite, cannon.position, null, 
                Color.White, cannon.rotation, cannon.center, 1.0f,SpriteEffects.None, 0);

            
            spriteBatch.End();
            base.Draw(gameTime);
        }
    }
}
